home *** CD-ROM | disk | FTP | other *** search
/ ...taking it to the Macs! / ...taking it to the Macs!.iso / Extras / ActiveX Mac SDK / ActiveX SDK / Headers / VARIANT.H < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-29  |  9.8 KB  |  279 lines  |  [TEXT/????]
  1. /*** 
  2. *variant.h
  3. *
  4. *  Copyright (C) 1992-1995, Microsoft Corporation.  All Rights Reserved.
  5. *
  6. *Purpose:
  7. *  This file declares VARIANT, and related data types.
  8. *
  9. *Implementation Notes:
  10. *  This file requires ole2.h
  11. *
  12. *****************************************************************************/
  13.  
  14. #ifndef _VARIANT_H_
  15. #define _VARIANT_H_
  16.  
  17.  
  18. #ifndef HUGEP
  19. # ifdef __MACAPI__
  20. #  define HUGEP FAR
  21. # else
  22. #  if WIN32
  23. #   define HUGEP
  24. #  else
  25. #   define HUGEP _huge
  26. #  endif
  27. # endif
  28. #endif
  29.  
  30. #ifndef FAR
  31. # ifdef _MAC
  32. #  define FAR
  33. # else
  34. #  ifdef WIN32
  35. #   define FAR
  36. #  else
  37. #   define FAR _far
  38. #  endif
  39. # endif
  40. #endif
  41.  
  42.  
  43. /* Forward Declarations */
  44.  
  45. #ifdef __cplusplus
  46. interface IDispatch;
  47. #else
  48. typedef interface IDispatch IDispatch;
  49. #endif
  50.  
  51.  
  52. #ifndef OLESTR
  53. #if defined(WIN32)
  54. typedef WCHAR OLECHAR;
  55. typedef LPWSTR LPOLESTR;
  56. typedef LPCWSTR LPCOLESTR;
  57. #define OLESTR(str) L##str
  58. #else
  59. typedef char OLECHAR;
  60. typedef OLECHAR FAR* LPOLESTR;
  61. //typedef OLECHAR * LPOLESTR;
  62. typedef const OLECHAR FAR* LPCOLESTR;
  63. #define OLESTR(str) str         
  64. #endif
  65. #endif
  66.  
  67. typedef OLECHAR FAR* BSTR;
  68. typedef BSTR FAR* LPBSTR;
  69.  
  70.  
  71. typedef struct FARSTRUCT tagSAFEARRAYBOUND {
  72.     unsigned long cElements;
  73.     long lLbound;
  74. } SAFEARRAYBOUND, FAR* LPSAFEARRAYBOUND;
  75.  
  76. typedef struct FARSTRUCT tagSAFEARRAY {
  77.     unsigned short cDims;
  78.     unsigned short fFeatures;
  79. #if defined(WIN32)
  80.     unsigned long cbElements;
  81.     unsigned long cLocks;
  82. #else
  83.     unsigned short cbElements;
  84.     unsigned short cLocks;
  85. #ifdef _MAC
  86.     Handle handle;
  87. #else
  88.     unsigned long handle;
  89. #endif
  90. #endif
  91.     void HUGEP* pvData;
  92.     SAFEARRAYBOUND rgsabound[1];
  93. } SAFEARRAY, FAR* LPSAFEARRAY;
  94.  
  95. #define FADF_AUTO       0x0001    /* array is allocated on the stack         */
  96. #define FADF_STATIC     0x0002    /* array is staticly allocated             */
  97. #define FADF_EMBEDDED   0x0004    /* array is embedded in a structure        */
  98. #define FADF_FIXEDSIZE  0x0010    /* array may not be resized or reallocated */
  99. #define FADF_BSTR       0x0100    /* an array of BSTRs                       */
  100. #define FADF_UNKNOWN    0x0200    /* an array of IUnknown*                   */
  101. #define FADF_DISPATCH   0x0400    /* an array of IDispatch*                  */
  102. #define FADF_VARIANT    0x0800    /* an array of VARIANTs                    */
  103. #define FADF_RESERVED   0xF0E8  /* bits reserved for future use            */
  104.  
  105.  
  106. /* 0 == FALSE, -1 == TRUE */
  107. typedef short VARIANT_BOOL;
  108.  
  109.  
  110. typedef double DATE;
  111.  
  112.  
  113. /* This is a helper struct for use in handling currency. */
  114. typedef struct FARSTRUCT tagCY {
  115. #ifdef _MAC
  116.     long      Hi;
  117.     unsigned long Lo;
  118. #else
  119.     unsigned long Lo;
  120.     long      Hi;
  121. #endif
  122. } CY;
  123.  
  124.  
  125. /*
  126.  * VARENUM usage key,
  127.  *
  128.  *   [V] - may appear in a VARIANT
  129.  *   [T] - may appear in a TYPEDESC
  130.  *   [P] - may appear in an OLE property set
  131.  *   [S] - may appear in a Safe Array
  132.  *
  133.  */
  134. enum VARENUM
  135. {
  136.     VT_EMPTY           = 0,   /* [V]   [P]     nothing                     */
  137.     VT_NULL            = 1,   /* [V]           SQL style Null              */
  138.     VT_I2              = 2,   /* [V][T][P][S]  2 byte signed int           */
  139.     VT_I4              = 3,   /* [V][T][P][S]  4 byte signed int           */
  140.     VT_R4              = 4,   /* [V][T][P][S]  4 byte real                 */
  141.     VT_R8              = 5,   /* [V][T][P][S]  8 byte real                 */
  142.     VT_CY              = 6,   /* [V][T][P][S]  currency                    */
  143.     VT_DATE            = 7,   /* [V][T][P][S]  date                        */
  144.     VT_BSTR            = 8,   /* [V][T][P][S]  OLE Automation string       */
  145.     VT_DISPATCH        = 9,   /* [V][T]   [S]  IDispatch FAR*              */
  146.     VT_ERROR           = 10,  /* [V][T]   [S]  SCODE                       */
  147.     VT_BOOL            = 11,  /* [V][T][P][S]  True=-1, False=0            */
  148.     VT_VARIANT         = 12,  /* [V][T][P][S]  VARIANT FAR*                */
  149.     VT_UNKNOWN         = 13,  /* [V][T]   [S]  IUnknown FAR*               */
  150.  
  151.     VT_I1              = 16,  /*    [T]        signed char                 */
  152.     VT_UI1             = 17,  /* [V][T]   [S]  unsigned char               */
  153.     VT_UI2             = 18,  /*    [T]        unsigned short              */
  154.     VT_UI4             = 19,  /*    [T]        unsigned short              */
  155.     VT_I8              = 20,  /*    [T][P]     signed 64-bit int           */
  156.     VT_UI8             = 21,  /*    [T]        unsigned 64-bit int         */
  157.     VT_INT             = 22,  /*    [T]        signed machine int          */
  158.     VT_UINT            = 23,  /*    [T]        unsigned machine int        */
  159.     VT_VOID            = 24,  /*    [T]        C style void                */
  160.     VT_HRESULT         = 25,  /*    [T]                                    */
  161.     VT_PTR             = 26,  /*    [T]        pointer type                */
  162.     VT_SAFEARRAY       = 27,  /*    [T]        (use VT_ARRAY in VARIANT)   */
  163.     VT_CARRAY          = 28,  /*    [T]        C style array               */
  164.     VT_USERDEFINED     = 29,  /*    [T]        user defined type           */
  165.     VT_LPSTR           = 30,  /*    [T][P]     null terminated string      */
  166.     VT_LPWSTR          = 31,  /*    [T][P]     wide null terminated string */
  167.  
  168.     VT_FILETIME        = 64,  /*       [P]     FILETIME                    */
  169.     VT_BLOB            = 65,  /*       [P]     Length prefixed bytes       */
  170.     VT_STREAM          = 66,  /*       [P]     Name of the stream follows  */
  171.     VT_STORAGE         = 67,  /*       [P]     Name of the storage follows */
  172.     VT_STREAMED_OBJECT = 68,  /*       [P]     Stream contains an object   */
  173.     VT_STORED_OBJECT   = 69,  /*       [P]     Storage contains an object  */
  174.     VT_BLOB_OBJECT     = 70,  /*       [P]     Blob contains an object     */
  175.     VT_CF              = 71,  /*       [P]     Clipboard format            */
  176.     VT_CLSID           = 72   /*       [P]     A Class ID                  */
  177. };
  178.  
  179. #define VT_VECTOR      0x1000 /*       [P]     simple counted array        */
  180. #define VT_ARRAY       0x2000 /* [V]           SAFEARRAY*                  */
  181. #define VT_BYREF       0x4000 /* [V]                                       */
  182. #define VT_RESERVED    0x8000
  183.  
  184.  
  185. typedef unsigned short VARTYPE;
  186.  
  187. typedef struct FARSTRUCT tagVARIANT VARIANT;
  188. typedef struct FARSTRUCT tagVARIANT FAR* LPVARIANT;
  189. typedef struct FARSTRUCT tagVARIANT VARIANTARG;
  190. typedef struct FARSTRUCT tagVARIANT FAR* LPVARIANTARG;
  191.  
  192. struct FARSTRUCT tagVARIANT{
  193.     VARTYPE vt;
  194.     unsigned short wReserved1;
  195.     unsigned short wReserved2;
  196.     unsigned short wReserved3;
  197.     union {
  198.       unsigned char bVal;         /* VT_UI1               */
  199.       short       iVal;             /* VT_I2                */
  200.       long       lVal;             /* VT_I4                */
  201.       float       fltVal;           /* VT_R4                */
  202.       double       dblVal;           /* VT_R8                */
  203.       VARIANT_BOOL bool;             /* VT_BOOL              */
  204.       SCODE       scode;            /* VT_ERROR             */
  205.       CY       cyVal;            /* VT_CY                */
  206.       DATE       date;             /* VT_DATE              */
  207.       BSTR       bstrVal;          /* VT_BSTR              */
  208.       IUnknown       FAR* punkVal;     /* VT_UNKNOWN           */
  209.       IDispatch       FAR* pdispVal;    /* VT_DISPATCH          */
  210.       SAFEARRAY       FAR* parray;         /* VT_ARRAY|*           */
  211.  
  212.       unsigned char FAR *pbVal;         /* VT_BYREF|VT_UI1      */
  213.       short       FAR* piVal;       /* VT_BYREF|VT_I2         */
  214.       long       FAR* plVal;       /* VT_BYREF|VT_I4         */
  215.       float       FAR* pfltVal;     /* VT_BYREF|VT_R4       */
  216.       double       FAR* pdblVal;     /* VT_BYREF|VT_R8       */
  217.       VARIANT_BOOL FAR* pbool;       /* VT_BYREF|VT_BOOL     */
  218.       SCODE       FAR* pscode;      /* VT_BYREF|VT_ERROR    */
  219.       CY       FAR* pcyVal;      /* VT_BYREF|VT_CY       */
  220.       DATE       FAR* pdate;       /* VT_BYREF|VT_DATE     */
  221.       BSTR       FAR* pbstrVal;    /* VT_BYREF|VT_BSTR     */
  222.       IUnknown  FAR* FAR* ppunkVal;  /* VT_BYREF|VT_UNKNOWN  */
  223.       IDispatch FAR* FAR* ppdispVal; /* VT_BYREF|VT_DISPATCH */
  224.       SAFEARRAY FAR* FAR* pparray;   /* VT_BYREF|VT_ARRAY|*  */
  225.       VARIANT       FAR* pvarVal;     /* VT_BYREF|VT_VARIANT  */
  226.  
  227.       void       FAR* byref;         /* Generic ByRef        */
  228.     }
  229. #if defined(NONAMELESSUNION) || (defined(_MAC) && !defined(__cplusplus) && !defined(_MSC_VER))
  230.     u
  231. #endif
  232.     ;
  233. };
  234.  
  235. #if defined(NONAMELESSUNION) || (defined(_MAC) && !defined(__cplusplus) && !defined(_MSC_VER))
  236. # define V_UNION(X, Y) ((X)->u.Y)
  237. #else
  238. # define V_UNION(X, Y) ((X)->Y)
  239. #endif
  240.  
  241. /* Variant access macros */
  242. #define V_VT(X)          ((X)->vt)
  243. #define V_ISBYREF(X)     (V_VT(X)&VT_BYREF)
  244. #define V_ISARRAY(X)     (V_VT(X)&VT_ARRAY)
  245. #define V_ISVECTOR(X)    (V_VT(X)&VT_VECTOR)
  246.  
  247. #define V_NONE(X)        V_I2(X)
  248. #define V_UI1(X)     V_UNION(X, bVal)
  249. #define V_UI1REF(X)     V_UNION(X, pbVal)
  250. #define V_I2(X)             V_UNION(X, iVal)
  251. #define V_I2REF(X)       V_UNION(X, piVal)
  252. #define V_I4(X)          V_UNION(X, lVal)
  253. #define V_I4REF(X)       V_UNION(X, plVal)
  254. #define V_R4(X)             V_UNION(X, fltVal)
  255. #define V_R4REF(X)       V_UNION(X, pfltVal)
  256. #define V_R8(X)             V_UNION(X, dblVal)
  257. #define V_R8REF(X)       V_UNION(X, pdblVal)
  258. #define V_BOOL(X)        V_UNION(X, bool)
  259. #define V_BOOLREF(X)     V_UNION(X, pbool)
  260. #define V_ERROR(X)       V_UNION(X, scode)
  261. #define V_ERRORREF(X)    V_UNION(X, pscode)
  262. #define V_CY(X)             V_UNION(X, cyVal)
  263. #define V_CYREF(X)       V_UNION(X, pcyVal)
  264. #define V_DATE(X)        V_UNION(X, date)
  265. #define V_DATEREF(X)     V_UNION(X, pdate)
  266. #define V_BSTR(X)        V_UNION(X, bstrVal)
  267. #define V_BSTRREF(X)     V_UNION(X, pbstrVal)
  268. #define V_UNKNOWN(X)     V_UNION(X, punkVal)
  269. #define V_UNKNOWNREF(X)  V_UNION(X, ppunkVal)
  270. #define V_DISPATCH(X)    V_UNION(X, pdispVal)
  271. #define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
  272. #define V_VARIANTREF(X)  V_UNION(X, pvarVal)
  273. #define V_ARRAY(X)       V_UNION(X, parray)
  274. #define V_ARRAYREF(X)    V_UNION(X, pparray)
  275. #define V_BYREF(X)       V_UNION(X, byref)
  276.  
  277. #endif /* _VARIANT_H_ */
  278.  
  279.